home *** CD-ROM | disk | FTP | other *** search
/ MaxiMac 2002 March / MaxiMac 124.iso / Macworld on CD n°124 / Logiciels pour Mac OS X / Internet / Utilisation / Snak 4.8 / UserScripts / pp-dcc.irc < prev    next >
Encoding:
Text File  |  2001-07-12  |  27.1 KB  |  921 lines  |  [TEXT/R*ch]
  1. # ########################################################################## #
  2. #                      PurePak - The sequel to TextBox                       #
  3. #                          A -+ TEXT +- production                           #
  4. # ########################################################################## #
  5. # Author: Crypt Keeper [ckeeper@axiom.access.one.net] (CKeeper on IRC)
  6. # Version 2.07
  7. #
  8. # This script requires at least ircII2.2.9 (Unix) or a fully ircII compatible
  9. # client.  It has only been tested under Unix with ircII2.2.9 and ircII2.8.2.
  10. #
  11. # If you edit this file, you must edit it with a Unix text editor or use
  12. # utilities like dos2unix/unix2dos to convert it to DOS to edit and then
  13. # back to Unix.  If it is edited in a DOS text editor it will be corrupted.
  14. #
  15. # PurePak version 2.07 IRC script
  16. # Copyright (C) 1995
  17. #
  18. # This program is free software; you can redistribute it and/or modify
  19. # it under the terms of the GNU General Public License as published by
  20. # the Free Software Foundation; either version 1, or (at your option)
  21. # any later version.
  22. #
  23. # This program is distributed in the hope that it will be useful,
  24. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  25. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26. # GNU General Public License for more details.
  27. #
  28. # You should have received a copy of the GNU General Public License
  29. # along with this program; if not, write to the Free Software
  30. # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31. # ########################################################################## #
  32.  
  33. EVAL ^if (!(PPVERS)) {/echo *** This is not a stand-alone script, it must be loaded after purepak.irc;//exit}
  34.  
  35. # DCC fileserver/manager script
  36. @ PP.DCC = 1
  37.  
  38. # ----------------------------------------------------------------------------
  39. # DCC alias
  40. # ----------------------------------------------------------------------------
  41.  
  42. alias xdcc {/dcc $*}
  43. alias dcc {
  44.     if ([$0])
  45.     {
  46.         if (match($0 SEND GET RAW TALK CHAT OFFER DOFFER LIST PLIST NOTICE DLDIR FRIENDS AUTOGET LOAD SAVE CLOSE LIMIT RENAME TMSG NOTE SERVER TIMEOUT QUEUEING PUBLIST AUTOCHAT))
  47.         {
  48.             if (match($0 RAW TALK RENAME TMSG SEND CHAT)) {//dcc $*}
  49.             if (match($0 CLOSE OFFER DOFFER LIST PLIST NOTICE DLDIR AUTOGET FRIENDS LOAD SAVE GET LIMIT NOTE SERVER TIMEOUT QUEUEING PUBLIST AUTOCHAT)) {/dcc.ucmd.$0 $1-}
  50.         } {/echo *** Unrecognized DCC command, type /pphelp dcc}
  51.     }
  52.     {
  53.         if (!PP.EPIC)
  54.         {
  55.             dcc.updatestatus
  56.             @ GDCCS = 0
  57.             if (DCC.GETS)
  58.             {
  59.                 @ GDCCS = 1
  60.                 echo *** Incoming files: From      Status      Read       Filename
  61.                 foreach DCC.GETS AA {
  62.                     EVAL ^foreach DCC.GETS.$AA XY {
  63.                         @ NK = decode($AA)
  64.                         if (word(0 $DCC.GETS[$AA][$XY]) == [W]) {@ ST = [Waiting]} {@ ST = [In Progress]}
  65.                         @ BT = word(2 $DCC.GETS[$AA][$XY])
  66.                         echo ***                 $[9]NK $[11]ST $[10]BT $right(24 $decode($XY))
  67.                     }
  68.                 }
  69.             }
  70.             if (DCC.SENDS)
  71.             {
  72.                 @ GDCCS = 1
  73.                 echo *** Outgoing files: To        Status      Written    Filename
  74.                 foreach DCC.SENDS AA {
  75.                     EVAL ^foreach DCC.SENDS.$AA XY {
  76.                         @ NK = decode($AA)
  77.                         if (word(0 $DCC.SENDS[$AA][$XY]) == [W]) {@ ST = [Waiting]} {@ ST = [In Progress]}
  78.                         @ BT = word(1 $DCC.SENDS[$AA][$XY])
  79.                         echo ***                 $[9]NK $[11]ST $[10]BT $right(24 $decode($XY))
  80.                     }
  81.                 }
  82.             }
  83.             if (DCC.CHATS)
  84.             {
  85.                 foreach DCC.CHATS AA {
  86.                     if (word(0 $DCC.CHATS[$AA]) == [W]) {/echo *** DCC CHAT request to $decode($AA) not established (waiting)}
  87.                     if (word(0 $DCC.CHATS[$AA]) == [O]) {/echo *** DCC CHAT offered from $decode($AA)}
  88.                     if (word(0 $DCC.CHATS[$AA]) == [A]) {/echo *** DCC CHAT active to $decode($AA)}
  89.                 }
  90.                 @ GDCCS = 1
  91.             }
  92.             if (GDCCS) {^assign -XY}
  93.             {/echo *** No active DCC CHAT, SEND, or GET connections}
  94.             ^assign -GDCCS
  95.         } {//dcc}
  96.     }
  97. }
  98.  
  99. EVAL ^if (!PP.SET.DCCDLDIR) {@ PP.SET.DCCDLDIR = [.]}
  100. EVAL ^if (!PP.SET.DCCAUTOGET) {@ PP.SET.DCCAUTOGET = [OFF]}
  101. EVAL ^if (!PP.SET.DCCFLAUTOGET) {@ PP.SET.DCCFLAUTOGET = [ON]}
  102. EVAL ^if (!PP.SET.DCCLIMIT) {@ PP.SET.DCCLIMIT = [-1]}
  103. EVAL ^if (!PP.SET.DCCSERVER) {@ PP.SET.DCCSERVER = [ON]}
  104. EVAL ^if (!PP.SET.DCCTIMEOUT) {@ PP.SET.DCCTIMEOUT = 90}
  105. EVAL ^if (!PP.SET.DCCPUBLIST) {@ PP.SET.DCCPUBLIST = [ON]}
  106. EVAL ^if (!PP.SET.DCCQUEUEING) {@ PP.SET.DCCQUEUEING = [ON]}
  107. EVAL ^if (!PP.SET.DCCAUTOCHAT) {@ PP.SET.DCCAUTOCHAT = [OFF]}
  108.  
  109. # ----------------------------------------------------------------------------
  110. # /dcc functions
  111. # ----------------------------------------------------------------------------
  112.  
  113. # /dcc autochat
  114. alias dcc.ucmd.autochat {
  115.     if (match($0 ON OFF)) {@ PP.SET.DCCAUTOCHAT = toupper($0)}
  116.     echo *** Auto accept DCC CHAT requests is now ${PP.SET.DCCAUTOCHAT}
  117. }
  118. # /dcc queueing
  119. alias dcc.ucmd.queueing {
  120.     if (match($0 ON OFF)) {@ PP.SET.DCCQUEUEING = toupper($0)}
  121.     echo *** Queueing of send requests if all slots are full is now ${PP.SET.DCCQUEUEING}
  122. }
  123. # /dcc server
  124. alias dcc.ucmd.server {
  125.     if (match($0 ON OFF)) {@ PP.SET.DCCSERVER = toupper($0)}
  126.     echo *** DCC server is now ${PP.SET.DCCSERVER}
  127. }
  128. # /dcc publist
  129. alias dcc.ucmd.publist {
  130.     if (match($0 ON OFF)) {@ PP.SET.DCCPUBLIST = toupper($0)}
  131.     echo *** Allow public CTCP XDCC LISTs is now ${PP.SET.DCCPUBLIST}
  132. }
  133. # /dcc note
  134. alias dcc.ucmd.note {
  135.     if ([$0]) {^if ([$0] != [-]) {@ DCC.NOTE = [$*]} {^assign -DCC.NOTE}}
  136.     if (DCC.NOTE) {/echo *** DCC offer list note: $DCC.NOTE} {/echo *** No DCC offer list note set}
  137. }
  138. # /dcc notice
  139. # Snak adaptation 1.4. Now only sends to the current channel - not all your channels
  140. # And don't make it reverse video.
  141. # Change wording to match the ircle fserv more closely
  142. alias dcc.ucmd.notice {
  143.     if (C)
  144.     {
  145.         if (dcc.havepacks()){
  146.             
  147.             if ($dcc.havepacks() == 1) {
  148.                 if ([$PP.SET.DCCLIMIT] != -1) {
  149.                     EVAL @ SEND_MSG = [** 1 pack ** ${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]
  150.                 }{EVAL @ SEND_MSG = [** 1 pack ** slots available]}
  151.             } { 
  152.             if ([$PP.SET.DCCLIMIT] != -1) {
  153.                     EVAL @ SEND_MSG = [** $dcc.havepacks() packs ** ${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]
  154.                 }{EVAL @ SEND_MSG = [** $dcc.havepacks() packs ** slots available]}
  155.             }
  156.             
  157.             ^pp.listmsg PRIVMSG $C
  158.             echo $SEND_MSG
  159.             
  160.             EVAL @ SEND_MSG = [** To request a file type "/msg $N xdcc send #n"]
  161.             ^pp.listmsg PRIVMSG $C
  162.             echo $SEND_MSG
  163.  
  164.             dcc.dolist 1 ^quote $0 $1 
  165.             dcc.dolist 1 ^echo 
  166.  
  167.  
  168.     #        ^pp.listmsg PRIVMSG $mychannels()
  169.     #        ^pp.listmsg PRIVMSG $C
  170.             ^assign -SEND_MSG
  171.         } {/echo *** You aren't offering any packs}
  172.         
  173.     } {/echo *** You aren't on any channels}
  174. }
  175. # /dcc offer
  176. # Snak adaptation 1.4. Modified to handle a list of file paths
  177. # Mac file paths can contain spaces, so input -files return a list that is separated with tabs
  178. # in another way. Use "listitem" to split it instead of "word"
  179. alias dcc.ucmd.offer {
  180.     ^input -files "Choose file(s) to offer: " if (1) {
  181.         if ([$0])
  182.         {
  183.             @ IDX = 0
  184.             while (listitem($IDX $*))
  185.             {
  186.                 if (fileexists($listitem($IDX $*))) {@ DCCFILS = DCCFILS##[$listitem($IDX $*) ]}
  187.                 {/echo *** File $listitem($IDX $*) does not exist or you have no permission to access}
  188.                 @ IDX = IDX + 1
  189.             }
  190.             if (DCCFILS)
  191.             {
  192.                 ^input "Enter a description for this pack: " if (1) {
  193.                     if ([$0])
  194.                     {
  195.                         @ IDX = 1
  196.                         while (DCCPACKS.FILES[$IDX]) {@ IDX = IDX + 1}
  197.                         @ DCCPACKS.FILES[$IDX] = DCCFILS
  198.                         @ DCCPACKS.DESC[$IDX] = [$*]
  199.                         @ DCCPACKS.STATS[$IDX] = [$W 0]
  200.                         echo *** Pack #$IDX added with files: ${DCCFILS}
  201.                         ^assign -IDX
  202.                         ^assign -DCCFILS
  203.                     }
  204.                     {
  205.                         ^assign -IDX
  206.                         ^assign -DCCFILS
  207.                         echo *** You must enter a description
  208.                     }
  209.                 }
  210.             }
  211.             {
  212.                 ^assign -IDX
  213.                 echo *** No files in pack!
  214.             }
  215.         } {/echo *** No files in pack!}
  216.     }
  217. }
  218. # /dcc doffer
  219. # snak adaptation 1.5 use listitem
  220. alias dcc.ucmd.doffer {
  221.     ^input "Enter pack number(s) to remove: " if (1) {
  222.         if ([$0])
  223.         {
  224.             @ AA = 0
  225.             while (word($AA $*))
  226.             {
  227.                 if (DCCPACKS.FILES[$listitem($AA $*)])
  228.                 {
  229.                     ^assign -DCCPACKS.FILES[$listitem($AA $*)]
  230.                     ^assign -DCCPACKS.DESC[$word($AA $*)]
  231.                     ^assign -DCCPACKS.STATS[$word($AA $*)]
  232.                     @ CTR = word($AA $*) + 1
  233.                     while (DCCPACKS.FILES[$CTR])
  234.                     {
  235.                         @ DCCPACKS.FILES[${CTR-1}] = DCCPACKS.FILES[$CTR]
  236.                         @ DCCPACKS.DESC[${CTR-1}] = DCCPACKS.DESC[$CTR]
  237.                         @ DCCPACKS.STATS[${CTR-1}] = DCCPACKS.STATS[$CTR]
  238.                         if (!(DCCPACKS.FILES[${CTR+1}]))
  239.                         {
  240.                             ^assign -DCCPACKS.FILES[$CTR]
  241.                             ^assign -DCCPACKS.DESC[$CTR]
  242.                             ^assign -DCCPACKS.STATS[$CTR]
  243.                         }
  244.                         @ CTR = CTR + 1
  245.                     }
  246.                     echo *** Pack #$word($AA $*) removed
  247.                 } {/echo *** There is no pack #$word($AA $*)}
  248.                 @ AA = AA + 1
  249.             }
  250.             ^assign -CTR
  251.         }
  252.     }
  253. }
  254. # /dcc list
  255. alias dcc.ucmd.list {
  256.     if (dcc.havepacks())
  257.     {
  258.         if (PP.SET.DCCLIMIT > 0) {/echo *** Files offered: [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  259.         {/echo *** Files offered:}
  260.         dcc.dolist 1 echo ***
  261.     } {/echo *** You have no files offered}
  262. }
  263. # /dcc save
  264. # Snak adaptation 1.4. Save package file in "home" directory, which for Snak is the scripts directory
  265. # Snak adaptation 1.5 use listitem
  266. #                      don't test to see if it is a full path, and don't prepend the stats
  267. #                       the addpack function can't deal with it - it is a bug in purepak 
  268. # Snak adaptation 1.7 use "log_extrainfo off" to prevent Snak from writing "server:" or "info:" before each line when logging
  269. alias dcc.ucmd.save {
  270.     if ([$0])
  271.     {
  272.         @ LF = [${HOME}/$0]
  273.         exec -name rm $PP.SET.RMCMD ${HOME}/$0
  274.         wait -CMD %rm if (1) {
  275.             if (PP.EPIC)
  276.             {
  277.                 @ FHANDLE = open($LF w)
  278.                 if (FHANDLE > 0) {/EVAL ^assign WC /write $FHANDLE}
  279.                 {/echo *** Could not open $LF}
  280.             }
  281.             {
  282.                 ^window new
  283.                 ^window log_extrainfo off
  284.                 ^window hold_mode off
  285.                 ^window name WRITEDCC
  286.                 ^window logfile $LF
  287.                 ^window log on
  288.                 @ WC = [/xecho -WINDOW WRITEDCC]
  289.             }
  290.             $WC # PurePak DCC module offer file, written $stime($time())
  291.             foreach DCCPACKS.FILES AA {
  292.                 @ CT = 0
  293.                 @ DFILES = []
  294.                 while (listitem($CT $DCCPACKS.FILES[$AA]))
  295.                 {
  296. #                    if (match(/* $listitem($CT $DCCPACKS.FILES[$AA]))) 
  297. #                    {
  298.                     @ DFILES = DFILES##[$listitem($CT $DCCPACKS.FILES[$AA]) ]
  299. #                    }
  300. #                    {
  301. #                    @ DFILES = DFILES##[$word(0 $DCCPACKS.STATS[$AA])/$listitem($CT $DCCPACKS.FILES[$AA]) ]
  302. #                    }
  303.                     
  304.                     @ CT = CT + 1
  305.                 }
  306.                 $WC ^dcc.addpack $encode($DFILES) $encode($DCCPACKS.DESC[$AA])
  307.             }
  308.             ^assign -CT
  309.             ^assign -DFILES
  310.             if (DCC.NOTE) {$WC ^dcc.ucmd.note $DCC.NOTE}
  311.             if (PP.EPIC)
  312.             {
  313.                 comment $close($FHANDLE)
  314.                 ^assign -FHANDLE
  315.             }
  316.             {
  317.                 ^window log off
  318.                 ^window kill
  319.             }
  320.             echo *** Current pack data written to $LF
  321.             ^assign -LF
  322.             ^assign -WC
  323.         }
  324.     } {/dcc.ucmd.save purepak.dcc}
  325. }
  326. # /dcc load
  327. alias dcc.ucmd.load {^if ([$0]) {//load $0} {//load purepak.dcc}}
  328. # /dcc plist
  329. alias dcc.ucmd.plist {
  330.     if (dcc.havepacks())
  331.     {
  332.         say Files offered: Type /msg $N xdcc send #N to get pack #N
  333.         if (PP.SET.DCCLIMIT > 0) {/say [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  334.         dcc.dolist 0 say
  335.     } {/echo *** You have no files offered}
  336. }
  337. # /dcc dldir
  338. alias dcc.ucmd.dldir {
  339.     if ([$0])
  340.     {
  341.         @ PP.SET.DCCDLDIR = [$0]
  342.         echo *** DCC download directory is now $0
  343.     } {/echo *** DCC download directory is now ${PP.SET.DCCDLDIR}}
  344. }
  345. # /dcc limit
  346. alias dcc.ucmd.limit {
  347.     if ([$0])
  348.     {
  349.         if (([$0] == [NONE])||([$0] == [OFF])) {@ PP.SET.DCCLIMIT = [-1]}
  350.         {
  351.             if (!isalpha($0)) {@ PP.SET.DCCLIMIT = [$0]}
  352.             {/echo *** Must be a numerical value}
  353.         }
  354.     }
  355.     if (PP.SET.DCCLIMIT == [-1]) {/echo *** DCC autosend file limit is now UNLIMITED}
  356.     {/echo *** DCC autosend file limit is now ${PP.SET.DCCLIMIT}}
  357. }
  358. # /dcc limit
  359. alias dcc.ucmd.timeout {
  360.     if ([$0])
  361.     {
  362.         if (([$0] == [NONE])||([$0] == [OFF])) {@ PP.SET.DCCTIMEOUT = [-1]}
  363.         {
  364.             if (!isalpha($0)) {@ PP.SET.DCCTIMEOUT = [$0]}
  365.             {/echo *** Must be a numerical value}
  366.         }
  367.     }
  368.     if (PP.SET.DCCTIMEOUT == [-1]) {/echo *** DCC autosend timeout is now UNLIMITED}
  369.     {/echo *** DCC autosend timeout is now ${PP.SET.DCCTIMEOUT}}
  370. }
  371. # /dcc autoget
  372. alias dcc.ucmd.autoget {
  373.     if (match($0 ON OFF)) {@ PP.SET.DCCAUTOGET = toupper($0)}
  374.     echo *** DCC autoget is now ${PP.SET.DCCAUTOGET}
  375. }
  376. # /dcc friends
  377. alias dcc.ucmd.friends {
  378.     if (match($0 ON OFF)) {@ PP.SET.DCCFLAUTOGET = toupper($0)}
  379.     echo *** DCC autoget from people in friends list is now ${PP.SET.DCCFLAUTOGET}
  380. }
  381. # /dcc get
  382. alias dcc.ucmd.get {
  383.     if ([$0])
  384.     {
  385.         if ([$1])
  386.         {
  387.             @ AA = 1
  388.             ^on ^window "% *No file offered in SEND*" {@ AA = 0}
  389.             //dcc get $0 $1
  390.             if (!AA) {/echo *** File $1 not offered by $0}
  391.         }
  392.         {
  393.             if ([$0])
  394.             {
  395.                 dcc.updatestatus
  396.                 @ FL = 0
  397.                 foreach DCC.GETS AA {
  398.                     if (toupper($decode($AA)) == toupper($0))
  399.                     {
  400.                         @ FL = 1
  401.                         EVAL foreach DCC.GETS.$AA XY {//dcc get $0 $decode($XY)}
  402.                         ^assign -XY
  403.                         echo *** Got all files offered by $0
  404.                     }
  405.                 }
  406.                 if (!FL) {/echo *** No files offered by $0}
  407.                 ^assign -FL
  408.             }
  409.             {
  410.                 dcc.updatestatus
  411.                 if (DCC.GETS)
  412.                 {
  413.                     foreach DCC.GETS AA {
  414.                         EVAL foreach DCC.GETS.$AA XY {//dcc get $decode($AA) $decode($XY)}
  415.                         ^assign -XY
  416.                     }
  417.                 } {/echo *** No files offered}
  418.             }
  419.         }
  420.     } {/echo *** /dcc get [<nick>] [<file>]}
  421. }
  422. # /dcc close
  423. alias dcc.ucmd.close {
  424.     if (match($0 RAW TALK CHAT RAW_LISTEN RAW_LIS)) {//dcc close $*}
  425.     {
  426.         @ AA = 0
  427.         if ([$0] == [SEND])
  428.         {
  429.             if ([$1])
  430.             {
  431.                 if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}
  432.                 if ([$2]) {//dcc close $*}
  433.                 {
  434.                     EVAL ^repeatcmd 30 //^dcc close send $1
  435.                     echo *** All DCC SENDs to $1 closed
  436.                 }
  437.             } {/echo *** /dcc close send <nick> [<file>]}
  438.             @ AA = 1
  439.         }
  440.         if ([$0] == [GET])
  441.         {
  442.             if ([$1])
  443.             {
  444.                 if ([$2]) {//dcc close $*}
  445.                 {
  446.                     EVAL ^repeatcmd 30 //^dcc close get $1
  447.                     echo *** All DCC GETs from $1 closed
  448.                 }
  449.             } {/echo *** /dcc close get <nick> [<file>]}
  450.             @ AA = 1
  451.         }
  452.         if (!AA) {/echo *** /dcc close <type> <nick> [<arguments>]}
  453.     }
  454. }
  455.  
  456. # ----------------------------------------------------------------------------
  457. # ON hooks and internal procedures
  458. # ----------------------------------------------------------------------------
  459. # Snak adaptation 1.6. Snak does its own DCC Autoaccept
  460. #         Furthermore, this code does not always work because it assumes that there are no spaces 
  461. #       in the filename. If there is then $6 will be incorrect and the script fails.
  462.  
  463. # on ^ctcp "% % DCC SEND % % % *" {
  464. #    
  465. #    echo *** DCC SEND 1 $1 2 $2 3 $3 4 $4 5 $5 6 $6
  466. #    if (([$6] > 1024)&&([$6] < 65535))
  467. #    {
  468. #        if (!ischannel($1))
  469. #        {
  470. #            if ((!!(PP.SET.DCCDLDIR))&&(PP.SET.DCCDLDIR != [.])) {//dcc rename $0 $4 ${PP.SET.DCCDLDIR}/$4}
  471. #            if (PP.SET.DCCAUTOGET == [ON])
  472. #            {
  473. #                echo *** Autogetting DCC SEND $4 from $0
  474. #                ^timer 2 //dcc get $0 $4
  475. #            }
  476. #            {
  477. #                if (PP.SET.DCCFLAUTOGET == [ON])
  478. #                {
  479. #                    foreach PP.FRIENDS AA {@ FNDS = FNDS##[ $PP.FRIENDS[$AA]]}
  480. #                    if (rmatch($0!$USERHOST() $FNDS))
  481. #                    {
  482. #                        echo *** Autogetting DCC SEND $4 from $0\; $0 is on your friends list
  483. #                        //dcc get $0 $4
  484. #                    }
  485. #                    ^assign -FNDS
  486. #                }
  487. #            }
  488. #        } {/echo *** Strange: $0 sent a DCC SEND request adressed to channel $1}
  489. #    }
  490. #    {
  491. #        ^timer 1 /echo *** DCC SEND request from $0 using priviledged port detected\; ignored (bomb?)
  492. #        //dcc close get $0 $4
  493. #    }
  494. # }
  495.  
  496. # on ^ctcp "% % DCC CHAT % % *" {
  497. #    if (([$6] < 1024)||([$6] > 65535))
  498. #    {
  499. #        ^timer 1 /echo *** DCC CHAT request from $0 using priviledged port detected\; ignored (bomb?)
  500. #        //dcc close chat $0
  501. #        //dcc close chat $0
  502. #    }
  503. #    {
  504. #        if (PP.SET.DCCAUTOCHAT == [ON])
  505. #        {
  506. #            ^timer 1 /echo *** Autogetting DCC CHAT request from $0
  507. #            //dcc chat $0
  508. #        }
  509. #        {
  510. #            if (PP.SET.DCCFLAUTOGET == [ON])
  511. #            {
  512. #                foreach PP.FRIENDS AA {@ FNDS = FNDS##[ $PP.FRIENDS[$AA]]}
  513. #                if (rmatch($0!$USERHOST() $FNDS))
  514. #                {
  515. #                    ^timer 1 /echo *** Autogetting DCC CHAT request from $0\; $0 is on your friends list
  516. #                    //dcc chat $0
  517. #                }
  518. #                ^assign -FNDS
  519. #            }
  520. #        }
  521. #    }
  522. # }
  523.  
  524. # We use a raw_irc for on msg to prevent a beep if BEEP_ON_MSG is set
  525. on ^raw_irc "% PRIVMSG % :XDCC *" {
  526.     if (!ischannel($2))
  527.     {
  528.         if (PP.SET.DCCSERVER == [ON]) {/dcc.msg $nickonly($0) $N $mid(${index(! $0)+1} 1000 $0) $4-}
  529.     }
  530.     {
  531.         if ([$2] == C) {/xecho -LEVEL PUBLIC <$nickonly($0)> $strip(: $3) $4-}
  532.         {/xecho -LEVEL PUBLIC <$nickonly($0):$2> $strip(: $3) $4-}
  533.     }
  534. }
  535. on ^ctcp "% % XDCC *" {^if (PP.SET.DCCSERVER == [ON]) {/dcc.msg $0 $1 $USERHOST() $3-}}
  536. alias dcc.msg {
  537.     if (right(10 $2) != LASTDCCER)
  538.     {
  539.         if (ischannel($1))
  540.         {
  541.             if (match($3 SEND LIST HELP VERSION LSPACK))
  542.             {
  543.                 if ([$3] == [LIST])
  544.                 {
  545.                     if (PP.SET.DCCPUBLIST == [ON])
  546.                     {
  547.                         if (dcc.havepacks()) {/dcc.msg $0 $N $2-}
  548.                     } {/echo *** $0 request for DCC LIST to everyone in $1 ignored}
  549.                 }
  550.                 {
  551.                     echo *** $0 request for DCC $toupper($3) to everyone in $1 ignored\; only LIST is allowed globally
  552.                     //^notice $0 Only DCC LISTs are allowed globally
  553.                 }
  554.             }
  555.             {
  556.                 echo *** Invalid DCC server command from $0 to $1
  557.                 //^notice $0 Unknown DCC server command\; type /msg $N XDCC HELP
  558.             }
  559.         }
  560.         {
  561.             if (match($3 SEND LIST HELP VERSION LSPACK)) {/dcc.mcmd.$3 $0 $2 $4-}
  562.             {
  563.                 echo *** Invalid DCC server command from $0
  564.                 //^notice $0 Unknown DCC server command\; type /msg $N XDCC HELP
  565.             }
  566.         }
  567.     }
  568.     if (!LASTDCCER) {^timer 3 ^assign -LASTDCCER}
  569.     @ LASTDCCER = right(10 $2)
  570. }
  571.  
  572. # Updates DCC status variables by capturing /dcc's output
  573. # Doesn't work on EPIC clients :P
  574. alias dcc.updatestatus {
  575.     ^on ^window "% Type*Nick*Status*Start*time*Sent*Read*Arguments*" {}
  576.     ^on ^window "% SEND *" {
  577.         if ([$3] == [Waiting]) {@ DCC.SENDS[$encode($2)][$encode($6)] = [W $4 $5]} {@ DCC.SENDS[$encode($2)][$encode($10)] = [A $8 $9]}
  578.         @ DCC.SENDS = 1
  579.     }
  580.     ^on ^window "% GET *" {
  581.         if ([$3] == [Offered]) {@ DCC.GETS[$encode($2)][$encode($6)] = [W $4 $5]} {@ DCC.GETS[$encode($2)][$encode($10)] = [A $8 $9]}
  582.         @ DCC.GETS = 1
  583.     }
  584.     ^on ^window "% RAW *" {}
  585.     ^on ^window "% CHAT *" {
  586.         if ([$3] == [Waiting]) {@ DCC.CHATS[$encode($2)] = [W $4 $5]}
  587.         {
  588.             if ([$3] == [Offered]) {@ DCC.CHATS[$encode($2)] = [O $4 $5]} {@ DCC.CHATS[$encode($2)] = [A $8 $9]}
  589.         }
  590.         @ DCC.CHATS = 1
  591.     }
  592.     ^on ^window "% RAW_LIS *raw_listen*" {}
  593.     ^on ^window "% TALK *" {}
  594.     foreach DCC.SENDS AA {/EVAL ^foreach DCC.SENDS.$AA BB {^assign -DCC.SENDS[$AA][$BB]}}
  595.     foreach DCC.GETS AA {/EVAL ^foreach DCC.GETS.$AA BB {^assign -DCC.GETS[$AA][$BB]}}
  596.     foreach DCC.CHATS AA {^assign -DCC.CHATS[$AA]}
  597.     ^assign -DCC.SENDS
  598.     ^assign -DCC.GETS
  599.     ^assign -DCC.CHATS
  600.     ^assign -BB
  601.     //dcc
  602.     ^on window - "% TALK *"
  603.     ^on window - "% CHAT *"
  604.     ^on window - "% RAW *"
  605.     ^on window - "% GET *"
  606.     ^on window - "% RAW_LIS *raw_listen*"
  607.     ^on window - "% Type*Nick*Status*Start*time*Sent*Read*Arguments*"
  608.     ^on window - "% SEND *"
  609. }
  610.  
  611. # Executed when a saved pack file loads
  612. # snak adaptation 1.5 use listitem
  613. alias dcc.addpack {
  614.     @ FILZ = decode($0)
  615.         
  616.     @ AA = 0
  617.     while (listitem($AA $FILZ))
  618.     {
  619.     
  620.     echo there
  621.         if (!fileexists($listitem($AA $FILZ)))
  622.         {
  623.             ^delword $listitem($AA $FILZ) $FILZ
  624.             echo *** LOAD: file $listitem($AA $FILZ) does not exist, removed from pack
  625.             @ FILZ = NLIST
  626.             ^assign -NLIST
  627.         }
  628.         @ AA = AA + 1
  629.     }
  630.     
  631.     if ([$#FILZ] > 0)
  632.     {
  633.         @ IDX = 1
  634.         while (DCCPACKS.FILES[$IDX]) {@ IDX = IDX + 1}
  635.         @ DCCPACKS.FILES[$IDX] = FILZ
  636.         @ DCCPACKS.DESC[$IDX] = decode($1)
  637.         @ DCCPACKS.STATS[$IDX] = [$W 0]
  638.         echo *** Pack #$IDX loaded with files: $FILZ
  639.         echo ***   - Description: $decode($1)
  640.         ^assign -IDX
  641.     } {/echo *** Pack not restored: no files}
  642.     ^assign -FILZ
  643. }
  644.  
  645. # Executed whenever the user changes nicks with /nick
  646. alias dcc.onnick {
  647.     if ([$0])
  648.     {
  649.         @ DCC.MYNICK = [$0]
  650.         EVAL ^on raw_irc - "${N}!% PRIVMSG $N :DCC SEND **"
  651.         EVAL ^on ^raw_irc "$0!% PRIVMSG $0 :DCC SEND **" {
  652.             @ DCC.SINT.FNAME = [$5]
  653.             @ DCC.SINT.FSIZE = strip( $8)
  654.             //^dcc close send $N
  655.             //^dcc close get $N
  656.             $DCC.ONREPCMD
  657.         }
  658.     }
  659. }
  660. EVAL ^on ^raw_irc "${N}!% PRIVMSG $N :DCC SEND **" {
  661.     @ DCC.SINT.FNAME = [$5]
  662.     @ DCC.SINT.FSIZE = strip( $8)
  663.     //^dcc close send $N
  664.     //^dcc close get $N
  665.     $DCC.ONREPCMD
  666. }
  667. @ DCC.ONREPCMD = [/dcc.norepcmd]
  668. alias dcc.norepcmd {
  669.     @ DCC.FSIZES[$encode($tolower($DCC.SINT.FNAME))] = DCC.SINT.FSIZE
  670.     ^assign -DCC.SINT.FNAME
  671.     ^assign -DCC.SINT.FSIZE
  672. }
  673.  
  674. # Checks to see if a file exists by trapping window output from a DCC SEND
  675. # to yourself.
  676. # Snak adaptation 1.4. Removed alias and made a built in function
  677.  
  678. #alias fileexists {
  679. #    @ EXISTS = 1
  680. #    ^on ^window "% *Cannot access*" {@ EXISTS = 0}
  681. #    ^on ^window * {}
  682. #    //dcc send $N $0
  683. #    ^on window - "% *Cannot access*"
  684. #    ^on window - *
  685. #    @ FUNCTION_RETURN = EXISTS
  686. #    ^assign -EXISTS
  687. #}
  688.  
  689. # args=<files>, returns sum of all file sizes, or 0 if a file's size isn't
  690. # saved in the buffer
  691. alias dcc.getpacksize {
  692.     @ PSIZE = 0
  693.     @ CT = 0
  694.     while ((!!word($CT $*))&&(PSIZE != [-1]))
  695.     {
  696.         @ FN = dcc.nameonly($word($CT $*))
  697.         if (DCC.FSIZES[$encode($tolower($FN))])
  698.         {
  699.             @ PSIZE = PSIZE + DCC.FSIZES[$encode($tolower($FN))]
  700.         } {@ PSIZE = [-1]}
  701.         @ CT = CT + 1
  702.     }
  703.     ^assign -CT
  704.     ^assign -FN
  705.     if (PSIZE == [-1]) {@ FUNCTION_RETURN = 0}
  706.     {@ FUNCTION_RETURN = PSIZE}
  707.     ^assign -PSIZE
  708. }
  709.  
  710. # /dcc.dolist <show filenames too?> <command to do list>
  711. alias dcc.dolist {
  712.     @ MAXV = 0
  713.     foreach DCCPACKS.FILES AA {^if (AA > MAXV) {@ MAXV = AA}}
  714.     @ AA = 0
  715.     while (AA <= MAXV)
  716.     {
  717.         if (DCCPACKS.FILES[$AA]) 
  718.         {
  719.             $1- #${AA} - $DCCPACKS.DESC[$AA]
  720.             @ FILS = DCCPACKS.FILES[$AA]
  721.             EVAL $1-    + [$#FILS file(s)] [$dcc.getpacksize($FILS) bytes] [downloaded $word(1 $DCCPACKS.STATS[$AA]) times]
  722.             if ([$0]) {$1- #${AA} - Files: $FILS}
  723.         }
  724.         @ AA = AA + 1
  725.     }
  726.     ^assign -FILS
  727.     ^assign -MAXV
  728.     if (DCC.NOTE) {$1- * Note: $DCC.NOTE}
  729. }
  730.  
  731. # Snak adaptation 1.4. returns number of packages offered
  732. alias dcc.havepacks {
  733.     @ FUNCTION_RETURN = 0
  734.     foreach DCCPACKS.FILES BsB {}
  735.     @ FUNCTION_RETURN = [$BsB]
  736.     ^assign -BsB
  737. }
  738.  
  739. # Queues a send for the timeout timer
  740. alias dcc.queuetimeout {@ DCC.TIMEOUTS[$encode($0)][$rand(99999)] = [$1 $2 $3]}
  741.  
  742. # Checks for DCC's that have timed out and runs queued DCC's
  743. on #^timer 22 * {
  744.     if (PP.SET.DCCTIMEOUT != [-1])
  745.     {
  746.         foreach DCC.TIMEOUTS AA {
  747.             EVAL ^foreach DCC.TIMEOUTS.$AA BB {
  748.                 if ([${time() - word(1 $DCC.TIMEOUTS[$AA][$BB])}] >= PP.SET.DCCTIMEOUT)
  749.                 {
  750.                     //^dcc close send $decode($AA) $word(2 $DCC.TIMEOUTS[$AA][$BB])
  751.                     //^dcc close send $decode($AA) ${W}/$word(0 $DCC.TIMEOUTS[$AA][$BB])
  752.                     if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}
  753.                     echo *** DCC SEND $word(2 $DCC.TIMEOUTS[$AA][$BB]) to $decode($AA) timed out
  754.                     //^notice $decode($AA) DCC SEND $word(2 $DCC.TIMEOUTS[$AA][$BB]) timed out
  755.                     ^assign -DCC.TIMEOUTS[$AA][$BB]
  756.                 }
  757.             }
  758.         }
  759.     }
  760.     if (PP.SET.DCCLIMIT != [-1])
  761.     {
  762.         while (dcc.gotqueue())
  763.         {
  764.             @ BB = 0
  765.             @ OLDESTQUEUE = 0
  766.             foreach DCC.SENDQUEUE AA {
  767.                 if ([${time() - AA}] > BB)
  768.                 {
  769.                     @ BB = time() - AA
  770.                     @ OLDESTQUEUE = AA
  771.                 }
  772.             }
  773.             echo *** Sending queued pack #$strip(# $word(2 $DCC.SENDQUEUE[$OLDESTQUEUE])) to $word(0 $DCC.SENDQUEUE[$OLDESTQUEUE])
  774.             ^alias echo {}
  775.             ^dcc.mcmd.send $DCC.SENDQUEUE[$OLDESTQUEUE]
  776.             ^alias -echo
  777.             ^assign -DCC.SENDQUEUE[$OLDESTQUEUE]
  778.         }
  779.         ^assign -OLDESTQUEUE
  780.     }
  781.     {
  782.         foreach DCC.SENDQUEUE AA {
  783.             echo *** Sending queued pack #$strip(# $word(2 $DCC.SENDQUEUE[$AA])) to $word(0 $DCC.SENDQUEUE[$AA])
  784.             ^alias echo {}
  785.             ^dcc.mcmd.send $DCC.SENDQUEUE[$AA]
  786.             ^alias -echo
  787.             ^assign -DCC.SENDQUEUE[$AA]
  788.         }
  789.     }
  790.     ^assign -BB
  791. }
  792.  
  793. # Returns true if files are queued and there are slots available
  794. alias dcc.gotqueue {
  795.     @ FUNCTION_RETURN = 0
  796.     foreach DCC.SENDQUEUE AB {^if (DCC.NSENDING < PP.SET.DCCLIMIT) {@ FUNCTION_RETURN = 1}}
  797.     ^assign -AB
  798. }
  799.  
  800. # Removes timeouts when sends are initiated
  801. on -window "% % DCC SEND connection to*established*" {
  802.     if (match(*[* $6)) {@ NIQ = left($index([ $6) $6)} {@ NIQ = [$6]}
  803.     foreach DCC.TIMEOUTS AA {^if (decode($AA) == NIQ) {^EVAL ^foreach DCC.TIMEOUTS.$AA BB {^assign -DCC.TIMEOUTS[$AA][$BB]}}}
  804.     ^assign -BB
  805.     ^assign -NIQ
  806. }
  807.  
  808. # Removes path from a filename
  809. alias dcc.nameonly {^if (match(*/* $0)) {@ FUNCTION_RETURN = mid(${rindex(/ $0)+1} 1000 $0)} {@ FUNCTION_RETURN = [$0]}}
  810.  
  811. # ----------------------------------------------------------------------------
  812. # User /msg command functions
  813. # ----------------------------------------------------------------------------
  814.  
  815. alias dcc.mcmd.version {
  816.     if (index(Y $PP.SET) == [-1])
  817.     {
  818.         //^notice $0 PurePak version $PPVERS DCC module
  819.         echo *** $0 [$strip( $1)] requested your version
  820.     }
  821. }
  822. alias dcc.mcmd.help {
  823.     //^notice $0 Available DCC server commands:
  824.     //^notice $0 HELP, LIST, SEND <#pack>, LSPACK <#pack>, VERSION
  825.     echo *** $0 [$strip( $1)] requested DCC server help
  826. }
  827. alias dcc.mcmd.list {
  828.     if (dcc.havepacks())
  829.     {
  830.         //^notice $0 Files available: Type /msg $N XDCC SEND #N to get pack #N
  831.         if (PP.SET.DCCLIMIT > 0) {//^notice $0 [${PP.SET.DCCLIMIT-DCC.NSENDING} slots available]}
  832.         EVAL ^dcc.dolist 0 //^notice $0
  833.         echo *** $0 [$strip( $1)] requested a list of files offered
  834.     } {//^notice $0 No files offered}
  835. }
  836. # snak adaptation 1.5 use listitem
  837. alias dcc.mcmd.lspack {
  838.     if (DCCPACKS.FILES[$strip(# $2)])
  839.     {
  840.         //^notice $0 Files in pack #$strip(# $2)
  841.         @ AA = 0
  842.         while (listitem($AA $DCCPACKS.FILES[$strip(# $2)]))
  843.         {
  844.             //^notice $0   $dcc.nameonly($listitem($AA $DCCPACKS.FILES[$strip(# $2)])) [$dcc.getpacksize($listitem($AA $DCCPACKS.FILES[$strip(# $2)])) bytes]
  845.             @ AA = AA + 1
  846.         }
  847.         echo *** $0 [$strip( $1)] requested a list of files in pack #$strip(# $2)
  848.     } {//^notice $0 There is no pack #$strip(# $2)}
  849. }
  850. @ DCC.NSENDING = 0
  851.  
  852. # snak adaptation 1.5 use listitem and don't check for /
  853.  
  854. alias dcc.mcmd.send {
  855.  
  856.     if (DCCPACKS.FILES[$strip(# $2)])
  857.     {
  858.         if ((DCC.NSENDING >= PP.SET.DCCLIMIT)&&(PP.SET.DCCLIMIT != [-1]))
  859.         {
  860.             if (PP.SET.DCCQUEUEING == [ON])
  861.             {
  862.                 @ ALREADY = 0
  863.                 foreach DCC.SENDQUEUE AA {
  864.                     if ((word(0 $DCC.SENDQUEUE[$AA]) == [$0])&&(word(2 $DCC.SENDQUEUE[$AA]) == [$2]))
  865.                     {
  866.                         //^notice $0 You already have a request for pack #$strip(# $2) queued
  867.                         @ ALREADY = 1
  868.                     }
  869.                 }
  870.                 if (!ALREADY)
  871.                 {
  872.                     @ DCC.SENDQUEUE[$time()] = [$*]
  873.                     echo *** DCC SEND request for pack #$strip(# $2) to $0 queued: no more slots available
  874.                     //^notice $0 No more DCC slots available: your request has been queued
  875.                 }
  876.                 ^assign -ALREADY
  877.             }
  878.             {
  879.                 //^notice $0 No more DCC slots available
  880.                 echo *** DCC SEND request for pack #$strip(# $2) to $0 denied: no more slots available
  881.             }
  882.         }
  883.         {
  884.             @ PACKNUM = strip(# $2)
  885.             //^notice $0 Sending you pack #$PACKNUM \(you will need $dcc.getpacksize($DCCPACKS.FILES[$PACKNUM]) bytes\)
  886.             //^notice $0 Type /dcc get $N <file> for each request received
  887.             @ CTR = 0
  888.             @ AA = word(1 $DCCPACKS.STATS[$PACKNUM])
  889.             @ DCCPACKS.STATS[$PACKNUM] = [$word(0 $DCCPACKS.STATS[$PACKNUM]) ${AA+1}]
  890.             while (listitem($CTR $DCCPACKS.FILES[$PACKNUM]))
  891.             {
  892.                 @ AA = listitem($CTR $DCCPACKS.FILES[$PACKNUM])
  893. #                {
  894. #                    //^dcc close send $0 $word(0 $DCCPACKS.STATS[$PACKNUM])/$AA
  895. #                    //^dcc send $0 $word(0 $DCCPACKS.STATS[$PACKNUM])/$AA
  896. #                    @ SF = [$word(0 $DCCPACKS.STATS[$PACKNUM])/$AA]
  897. #                }
  898. #                {
  899.                     //^dcc close send $0 $AA
  900.                     //^dcc send $0 $AA
  901.                     @ SF = AA
  902. #                }
  903.                 if (PP.SET.DCCTIMEOUT > 0) {^dcc.queuetimeout $0 $dcc.nameonly($AA) $time() $SF}
  904.                 @ DCC.NSENDING = DCC.NSENDING + 1
  905.                 if ((PP.SET.DCCLIMIT != [-1])&&(DCC.NSENDING > PP.SET.DCCLIMIT)) {@ DCC.NSENDING = PP.SET.DCCLIMIT}
  906.                 @ CTR = CTR + 1
  907.             }
  908.             ^assign -SF
  909.             ^assign -CTR
  910.             echo *** DCC pack #$PACKNUM sent to $0 [$strip( $1)]
  911.             ^assign -PACKNUM
  912.         }
  913.     } {//^notice $0 There is no pack #$strip(# $2)}
  914. }
  915. on -window "% % DCC SEND:% *completed*" {^if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}}
  916. on -window "% % DCC SEND:% *lost*" {^if (DCC.NSENDING > 0) {@ DCC.NSENDING = DCC.NSENDING - 1}}
  917.  
  918. # ----------------------------------------------------------------------------
  919.  
  920. EVAL ^if (!PP.SET.NOSTARTUP) {/echo -- PurePak DCC server module loaded}
  921.